// Machine generated IDispatch wrapper class(es) created with ClassWizard

#include "stdafx.h"
#include "wp2_5.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif



/////////////////////////////////////////////////////////////////////////////
// IGxServer properties

/////////////////////////////////////////////////////////////////////////////
// IGxServer operations

CString IGxServer::GetLastMessage()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxServer::GetServerInfo()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxServer::GetTradeStore()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxServer::GetSymbolStore()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxServer::GetChartStore()
{
	LPDISPATCH result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxServerInfo properties

/////////////////////////////////////////////////////////////////////////////
// IGxServerInfo operations

BOOL IGxServerInfo::GetConnected()
{
	BOOL result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

double IGxServerInfo::GetServerDate()
{
	double result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

CString IGxServerInfo::GetLastMessage()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

double IGxServerInfo::GetTradeDate()
{
	double result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxServerInfo::GetMarketType()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxServerInfoEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxServerInfoEvents operations

void IGxServerInfoEvents::OnDisconnected(LPDISPATCH aGxServerInfo)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxServerInfo);
}


/////////////////////////////////////////////////////////////////////////////
// IGxSymbolStore properties

/////////////////////////////////////////////////////////////////////////////
// IGxSymbolStore operations

LPDISPATCH IGxSymbolStore::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxSymbolStore::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxSymbolStore::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetStocks()
{
	LPDISPATCH result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetSpreads()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetFutures()
{
	LPDISPATCH result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetOptionMonths()
{
	LPDISPATCH result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetK200Index()
{
	LPDISPATCH result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetNearestFuture()
{
	LPDISPATCH result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetNearestOptMonth()
{
	LPDISPATCH result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IGxSymbolStore::SetGreeksParam(long GreeksCalcType, double dUnderMixRatio, double dCallVol, double dPutVol)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		GreeksCalcType, dUnderMixRatio, dCallVol, dPutVol);
	return result;
}

BOOL IGxSymbolStore::GetQuoteEventFiltered()
{
	BOOL result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

void IGxSymbolStore::SetQuoteEventFiltered(BOOL bNewValue)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 bNewValue);
}

long IGxSymbolStore::GetQuoteEventInterval()
{
	long result;
	InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IGxSymbolStore::SetQuoteEventInterval(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

BOOL IGxSymbolStore::GetPriceEventFiltered()
{
	BOOL result;
	InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

void IGxSymbolStore::SetPriceEventFiltered(BOOL bNewValue)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 bNewValue);
}

long IGxSymbolStore::GetPriceEventInterval()
{
	long result;
	InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IGxSymbolStore::SetPriceEventInterval(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

BOOL IGxSymbolStore::GetTickEventFiltered()
{
	BOOL result;
	InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

void IGxSymbolStore::SetTickEventFiltered(BOOL bNewValue)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 bNewValue);
}

long IGxSymbolStore::GetTickEventInterval()
{
	long result;
	InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IGxSymbolStore::SetTickEventInterval(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

LPDISPATCH IGxSymbolStore::GetAllFutures()
{
	LPDISPATCH result;
	InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetAllSpreads()
{
	LPDISPATCH result;
	InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetBondFutures()
{
	LPDISPATCH result;
	InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetCurrencyFutures()
{
	LPDISPATCH result;
	InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbolStore::GetProductFutures()
{
	LPDISPATCH result;
	InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IGxSymbolStore::GetEstFillIncluded()
{
	BOOL result;
	InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

void IGxSymbolStore::SetEstFillIncluded(BOOL bNewValue)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 bNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// IGxSymbols properties

/////////////////////////////////////////////////////////////////////////////
// IGxSymbols operations

LPDISPATCH IGxSymbols::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxSymbols::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxSymbols::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxSymbol properties

/////////////////////////////////////////////////////////////////////////////
// IGxSymbol operations

CString IGxSymbol::GetCode()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IGxSymbol::GetDesc()
{
	CString result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IGxSymbol::GetKorDesc()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IGxSymbol::GetEngDesc()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetUnderlyingType()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetSymbolType()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetOptionType()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetStrikePrice()
{
	double result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

CString IGxSymbol::GetClosingMonth()
{
	CString result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetMatureDate()
{
	double result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetTrailingDays()
{
	long result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetPointValue()
{
	double result;
	InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetCDRate()
{
	double result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetHighLimit()
{
	double result;
	InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetLowLimit()
{
	double result;
	InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetCBHigh()
{
	double result;
	InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetCBLow()
{
	double result;
	InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetBasePrice()
{
	double result;
	InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

VARIANT IGxSymbol::GetVLongThValues()
{
	VARIANT result;
	InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT IGxSymbol::GetVShortThValues()
{
	VARIANT result;
	InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetPrecision()
{
	long result;
	InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

BOOL IGxSymbol::GetIsNearest()
{
	BOOL result;
	InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IGxSymbol::GetIsATM()
{
	BOOL result;
	InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetIv()
{
	double result;
	InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetPrevOpenInterest()
{
	long result;
	InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetOpen()
{
	double result;
	InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetHigh()
{
	double result;
	InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetLow()
{
	double result;
	InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetClose()
{
	double result;
	InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetChange()
{
	double result;
	InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetOpenInterest()
{
	long result;
	InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetAccVolume()
{
	long result;
	InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CY IGxSymbol::GetAccAmount()
{
	CY result;
	InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_CY, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbol::GetQuote()
{
	LPDISPATCH result;
	InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxSymbol::GetLastTick()
{
	LPDISPATCH result;
	InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IGxSymbol::GetCanOrder()
{
	BOOL result;
	InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

CString IGxSymbol::GetLastMessage()
{
	CString result;
	InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetThPrice()
{
	double result;
	InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetIv2()
{
	double result;
	InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetDelta()
{
	double result;
	InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetGamma()
{
	double result;
	InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetTheta()
{
	double result;
	InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetVega()
{
	double result;
	InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetLamda()
{
	double result;
	InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetIntrinsicValue()
{
	double result;
	InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxSymbol::GetTimeValue()
{
	double result;
	InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxSymbol::GetEventOmitCount()
{
	long result;
	InvokeHelper(0x31, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

VARIANT IGxSymbol::GetVThValues()
{
	VARIANT result;
	InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxSymbolEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxSymbolEvents operations

void IGxSymbolEvents::OnPriceChanged(LPDISPATCH aGxSymbol)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxSymbol);
}


/////////////////////////////////////////////////////////////////////////////
// IGxQuote properties

/////////////////////////////////////////////////////////////////////////////
// IGxQuote operations

double IGxQuote::GetUpdateTime()
{
	double result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

VARIANT IGxQuote::GetVPrices()
{
	VARIANT result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT IGxQuote::GetVQtys()
{
	VARIANT result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT IGxQuote::GetVCnts()
{
	VARIANT result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT IGxQuote::GetVQuotes()
{
	VARIANT result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

double IGxQuote::Price(long PositionType, long iIndex)
{
	double result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		PositionType, iIndex);
	return result;
}

long IGxQuote::Qty(long PositionType, long iIndex)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		PositionType, iIndex);
	return result;
}

long IGxQuote::Cnt(long PositionType, long iIndex)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		PositionType, iIndex);
	return result;
}

CString IGxQuote::GetLastMessage()
{
	CString result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long IGxQuote::GetEventOmitCount()
{
	long result;
	InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxQuoteEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxQuoteEvents operations

void IGxQuoteEvents::OnQuoteChanged(LPDISPATCH aGxSymbol, LPDISPATCH aGxQuote)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxSymbol, aGxQuote);
}


/////////////////////////////////////////////////////////////////////////////
// IGxLastTick properties

/////////////////////////////////////////////////////////////////////////////
// IGxLastTick operations

double IGxLastTick::GetTime()
{
	double result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxLastTick::GetLSType()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxLastTick::GetPrice()
{
	double result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxLastTick::GetVolume()
{
	double result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxLastTick::GetAccVolume()
{
	double result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxLastTick::GetOpenInterest()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxLastTick::GetLastMessage()
{
	CString result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxLastTickEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxLastTickEvents operations

void IGxLastTickEvents::OnNewTick(LPDISPATCH aGxSymbol, LPDISPATCH aGxLastTick)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxSymbol, aGxLastTick);
}


/////////////////////////////////////////////////////////////////////////////
// IGxOptionMonths properties

/////////////////////////////////////////////////////////////////////////////
// IGxOptionMonths operations

LPDISPATCH IGxOptionMonths::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxOptionMonths::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxOptionMonths::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxOptionMonth properties

/////////////////////////////////////////////////////////////////////////////
// IGxOptionMonth operations

CString IGxOptionMonth::GetMonthCode()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IGxOptionMonth::GetMonthDesc()
{
	CString result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOptionMonth::GetStrikePrices()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString IGxOptionMonth::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxStrikePrices properties

/////////////////////////////////////////////////////////////////////////////
// IGxStrikePrices operations

LPDISPATCH IGxStrikePrices::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxStrikePrices::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxStrikePrices::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxStrikePrice properties

/////////////////////////////////////////////////////////////////////////////
// IGxStrikePrice operations

CString IGxStrikePrice::GetLastMessage()
{
	CString result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxStrikePrice::GetCall()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxStrikePrice::GetPut()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

double IGxStrikePrice::GetStrikePrice()
{
	double result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

CString IGxStrikePrice::GetStrikeDesc()
{
	CString result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxTradeStore properties

/////////////////////////////////////////////////////////////////////////////
// IGxTradeStore operations

LPDISPATCH IGxTradeStore::GetAccounts()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxTradeStore::GetPositions()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxTradeStore::GetOrders()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxTradeStore::GetFills()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxTradeStore::GetConfirms()
{
	LPDISPATCH result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxTradeStore::GetOrderHandler()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxTradeStore::GetEmHandler()
{
	LPDISPATCH result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString IGxTradeStore::GetLastMessage()
{
	CString result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void IGxTradeStore::Synchronize()
{
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IGxOrders properties

/////////////////////////////////////////////////////////////////////////////
// IGxOrders operations

LPDISPATCH IGxOrders::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxOrders::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxOrders::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrders::FindOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iKseAcptNo)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		stAccountCode, stSymbolCode, iKseAcptNo);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxOrderEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxOrderEvents operations

void IGxOrderEvents::OnNewOrder(LPDISPATCH aGxOrder)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxOrder);
}

void IGxOrderEvents::OnOrderUpdated(LPDISPATCH aGxOrder)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxOrder);
}


/////////////////////////////////////////////////////////////////////////////
// IGxOrder properties

/////////////////////////////////////////////////////////////////////////////
// IGxOrder operations

LPDISPATCH IGxOrder::GetAccount()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrder::GetSymbol()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrder::GetPosition()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetOrderType()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetPositionType()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetPriceType()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetQty()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetLnitQty()
{
	long result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxOrder::GetPrice()
{
	double result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetOrderState()
{
	long result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetSrvAcptNo()
{
	long result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetKseAcptNo()
{
	long result;
	InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxOrder::GetKseAcptTime()
{
	double result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetFillQty()
{
	long result;
	InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxOrder::GetLastFillPrice()
{
	double result;
	InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetUnFillQty()
{
	long result;
	InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrder::GetTargetOrder()
{
	LPDISPATCH result;
	InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetTargetSrvAcptNo()
{
	long result;
	InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetTargetKseAcptNo()
{
	long result;
	InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrder::GetFills()
{
	LPDISPATCH result;
	InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrder::GetConfirms()
{
	LPDISPATCH result;
	InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString IGxOrder::GetLastMessage()
{
	CString result;
	InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long IGxOrder::GetFillType()
{
	long result;
	InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxAccounts properties

/////////////////////////////////////////////////////////////////////////////
// IGxAccounts operations

LPDISPATCH IGxAccounts::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxAccounts::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxAccounts::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxAccounts::FindAccount(LPCTSTR stDesc)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		stDesc);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxAccountEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxAccountEvents operations

void IGxAccountEvents::OnAccountUpdated(LPDISPATCH aGxAccount)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxAccount);
}


/////////////////////////////////////////////////////////////////////////////
// IGxAccount properties

/////////////////////////////////////////////////////////////////////////////
// IGxAccount operations

CString IGxAccount::GetCode()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IGxAccount::GetHiphenedCode()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IGxAccount::GetDesc()
{
	CString result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

BOOL IGxAccount::GetAuthenticated()
{
	BOOL result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IGxAccount::GetApplyBiasMargin()
{
	BOOL result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetDepositTotal()
{
	double result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetDepositCash()
{
	double result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetMarginTotal()
{
	double result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetMarginCash()
{
	double result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetLiquidTotal()
{
	double result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetLiquidCash()
{
	double result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetCommission()
{
	double result;
	InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetDailyPL()
{
	double result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetAccPL()
{
	double result;
	InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxAccount::GetEvalPL()
{
	double result;
	InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxAccount::GetOrders()
{
	LPDISPATCH result;
	InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxAccount::GetPositions()
{
	LPDISPATCH result;
	InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString IGxAccount::GetLastMessage()
{
	CString result;
	InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void IGxAccount::ForceUpdate()
{
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long IGxAccount::GetMaxOrderQty(LPCTSTR stSymbolCode, long PositionType, double dPrice)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_R8;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		stSymbolCode, PositionType, dPrice);
	return result;
}

double IGxAccount::GetShortOptMargin(LPCTSTR stSymbolCode)
{
	double result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		stSymbolCode);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxPositions properties

/////////////////////////////////////////////////////////////////////////////
// IGxPositions operations

LPDISPATCH IGxPositions::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxPositions::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxPositions::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxPositions::FindPosition(LPCTSTR stAccountCode, LPCTSTR stSymbolCode)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		stAccountCode, stSymbolCode);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxPositionEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxPositionEvents operations

void IGxPositionEvents::OnNewPosition(LPDISPATCH aGxPosition)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxPosition);
}

void IGxPositionEvents::OnPositionUpdated(LPDISPATCH aGxPosition)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxPosition);
}

void IGxPositionEvents::OnEvalPLUpdated(LPDISPATCH aGxPosition)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxPosition);
}


/////////////////////////////////////////////////////////////////////////////
// IGxPosition properties

/////////////////////////////////////////////////////////////////////////////
// IGxPosition operations

LPDISPATCH IGxPosition::GetAccount()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxPosition::GetSymbol()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxPosition::GetQty()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxPosition::GetPrevQty()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxPosition::GetTodayQty()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxPosition::GetAvgPrice()
{
	double result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxPosition::GetEvalPL()
{
	double result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxPosition::GetShortOrderQty()
{
	long result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxPosition::GetLongOrderQty()
{
	long result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxPosition::GetLastMessage()
{
	CString result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxFills properties

/////////////////////////////////////////////////////////////////////////////
// IGxFills operations

LPDISPATCH IGxFills::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxFills::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxFills::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxFillEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxFillEvents operations

void IGxFillEvents::OnNewFill(LPDISPATCH aGxFill)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxFill);
}

void IGxFillEvents::OnFillUpdated(LPDISPATCH aGxFill)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxFill);
}


/////////////////////////////////////////////////////////////////////////////
// IGxFill properties

/////////////////////////////////////////////////////////////////////////////
// IGxFill operations

LPDISPATCH IGxFill::GetOrder()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxFill::GetFillNo()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxFill::GetFillQty()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxFill::GetFillPrice()
{
	double result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxFill::GetFillTime()
{
	double result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxFill::GetNearPrice()
{
	double result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxFill::GetFarPrice()
{
	double result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

CString IGxFill::GetLastMessage()
{
	CString result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxConfirms properties

/////////////////////////////////////////////////////////////////////////////
// IGxConfirms operations

LPDISPATCH IGxConfirms::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxConfirms::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxConfirms::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxConfirmEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxConfirmEvents operations

void IGxConfirmEvents::OnNewConfirm(LPDISPATCH aGxConfirm)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxConfirm);
}


/////////////////////////////////////////////////////////////////////////////
// IGxConfirm properties

/////////////////////////////////////////////////////////////////////////////
// IGxConfirm operations

LPDISPATCH IGxConfirm::GetOrder()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

double IGxConfirm::GetArrivedTime()
{
	double result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxConfirm::GetReqQty()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxConfirm::GetConfirmQty()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxConfirm::GetConfirmPrice()
{
	double result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

long IGxConfirm::GetPriceType()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxConfirm::GetRjtReason()
{
	CString result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IGxConfirm::GetLastMessage()
{
	CString result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxOrderHandler properties

/////////////////////////////////////////////////////////////////////////////
// IGxOrderHandler operations

LPDISPATCH IGxOrderHandler::GetOrderReqs()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxOrderHandler::GetWaitCount()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxOrderHandler::GetLastMessage()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrderHandler::PutNewOrder(LPCTSTR stAccount, LPCTSTR stSymbol, long PositionType, long PriceType, long iQty, double dPrice)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_R8;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		stAccount, stSymbol, PositionType, PriceType, iQty, dPrice);
	return result;
}

LPDISPATCH IGxOrderHandler::PutChangeOrder(LPDISPATCH aTargetOrder, long iChangeQty, long PriceType, double dPrice)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4 VTS_I4 VTS_R8;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		aTargetOrder, iChangeQty, PriceType, dPrice);
	return result;
}

LPDISPATCH IGxOrderHandler::PutCancelOrder(LPDISPATCH aTargetOrder, long iCancelQty)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		aTargetOrder, iCancelQty);
	return result;
}

void IGxOrderHandler::Send()
{
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IGxOrderHandler::PutNewOrder2(LPCTSTR stAccount, LPCTSTR stSymbol, long PositionType, long PriceType, long iQty, double dPrice, long FillType)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_R8 VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		stAccount, stSymbol, PositionType, PriceType, iQty, dPrice, FillType);
	return result;
}

LPDISPATCH IGxOrderHandler::PutChangeOrder2(LPDISPATCH aTargetOrder, long iChangeQty, long PriceType, double dPrice, long FillType)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4 VTS_I4 VTS_R8 VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		aTargetOrder, iChangeQty, PriceType, dPrice, FillType);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxOrderHandlerEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxOrderHandlerEvents operations

void IGxOrderHandlerEvents::OnStateChanged(LPDISPATCH aGxOrderReq)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxOrderReq);
}


/////////////////////////////////////////////////////////////////////////////
// IGxOrderReqs properties

/////////////////////////////////////////////////////////////////////////////
// IGxOrderReqs operations

LPDISPATCH IGxOrderReqs::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxOrderReqs::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxOrderReqs::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxOrderReq properties

/////////////////////////////////////////////////////////////////////////////
// IGxOrderReq operations

LPDISPATCH IGxOrderReq::GetAccount()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrderReq::GetSymbol()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxOrderReq::GetPositionType()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrderReq::GetPriceType()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrderReq::GetQty()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

double IGxOrderReq::GetPrice()
{
	double result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxOrderReq::GetTargetOrder()
{
	LPDISPATCH result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxOrderReq::GetOrderType()
{
	long result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrderReq::GetState()
{
	long result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxOrderReq::GetSrvAcptNo()
{
	long result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxOrderReq::GetRjtReason()
{
	CString result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

BOOL IGxOrderReq::GetIsDone()
{
	BOOL result;
	InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IGxOrderReq::GetIsDoing()
{
	BOOL result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

CString IGxOrderReq::GetLastMessage()
{
	CString result;
	InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxEmHandler properties

/////////////////////////////////////////////////////////////////////////////
// IGxEmHandler operations

CString IGxEmHandler::GetLastMessage()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

BOOL IGxEmHandler::SendEmNewOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long PositionType, long PriceType, long iQty, double dPrice)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_R8;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		stAccountCode, stSymbolCode, PositionType, PriceType, iQty, dPrice);
	return result;
}

BOOL IGxEmHandler::SendEmChangeOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iSrvAcptNo, long iQty, long PriceType, double dPrice)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_R8;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		stAccountCode, stSymbolCode, iSrvAcptNo, iQty, PriceType, dPrice);
	return result;
}

BOOL IGxEmHandler::SendEmCancelOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iSrvAcptNo, long iQty)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		stAccountCode, stSymbolCode, iSrvAcptNo, iQty);
	return result;
}

BOOL IGxEmHandler::SendEmNewOrder2(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long PositionType, long PriceType, long iQty, double dPrice, long FillType)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_R8 VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		stAccountCode, stSymbolCode, PositionType, PriceType, iQty, dPrice, FillType);
	return result;
}

BOOL IGxEmHandler::SendEmChangeOrder2(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iSrvAcptNo, long iQty, long PriceType, double dPrice, long FillType)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_R8 VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		stAccountCode, stSymbolCode, iSrvAcptNo, iQty, PriceType, dPrice, FillType);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxEmHandlerEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxEmHandlerEvents operations

void IGxEmHandlerEvents::OnEmOrderArrived(long OrderType, BOOL bSuccess, long iSrvAcptNo, LPCTSTR stMsg)
{
	static BYTE parms[] =
		VTS_I4 VTS_BOOL VTS_I4 VTS_BSTR;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 OrderType, bSuccess, iSrvAcptNo, stMsg);
}


/////////////////////////////////////////////////////////////////////////////
// IGxChartStore properties

/////////////////////////////////////////////////////////////////////////////
// IGxChartStore operations

LPDISPATCH IGxChartStore::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxChartStore::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxChartStore::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxChartStore::Add()
{
	LPDISPATCH result;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IGxChartStore::Remove(long Index)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Index);
	return result;
}

BOOL IGxChartStore::RemoveBySerialNo(long iSerialNo)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		iSerialNo);
	return result;
}

BOOL IGxChartStore::GetUpdateEventFiltered()
{
	BOOL result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

void IGxChartStore::SetUpdateEventFiltered(BOOL bNewValue)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 bNewValue);
}

long IGxChartStore::GetUpdateEventInterval()
{
	long result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IGxChartStore::SetUpdateEventInterval(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// IGxChartData properties

/////////////////////////////////////////////////////////////////////////////
// IGxChartData operations

LPDISPATCH IGxChartData::GetSymbol()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IGxChartData::GetDataType()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxChartData::GetBase()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxChartData::GetPeriod()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long IGxChartData::GetDataCount()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH IGxChartData::GetTerms()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IGxChartData::GetReady()
{
	BOOL result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IGxChartData::GetRequesting()
{
	BOOL result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

long IGxChartData::GetSerialNo()
{
	long result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxChartData::GetLastMessage()
{
	CString result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

BOOL IGxChartData::Define(LPCTSTR stSymbolCode, long DataType, long Base, long iPeriod, long iCount)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		stSymbolCode, DataType, Base, iPeriod, iCount);
	return result;
}

void IGxChartData::UnDefine()
{
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IGxChartDataEvents properties

/////////////////////////////////////////////////////////////////////////////
// IGxChartDataEvents operations

void IGxChartDataEvents::OnDataRefreshed(LPDISPATCH aGxChartData)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxChartData);
}

void IGxChartDataEvents::OnDataAdded(LPDISPATCH aGxChartData)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxChartData);
}

void IGxChartDataEvents::OnDataUpdated(LPDISPATCH aGxChartData)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 aGxChartData);
}


/////////////////////////////////////////////////////////////////////////////
// IGxTerms properties

/////////////////////////////////////////////////////////////////////////////
// IGxTerms operations

LPDISPATCH IGxTerms::GetItem(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

long IGxTerms::GetCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString IGxTerms::GetLastMessage()
{
	CString result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGxTerm properties

/////////////////////////////////////////////////////////////////////////////
// IGxTerm operations

double IGxTerm::GetStartTime()
{
	double result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetLastTime()
{
	double result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetOpen()
{
	double result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetHigh()
{
	double result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetLow()
{
	double result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetClose()
{
	double result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetVolume()
{
	double result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetAccVolume()
{
	double result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

double IGxTerm::GetOpenInterest()
{
	double result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

CString IGxTerm::GetLastMessage()
{
	CString result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}
